from typing import List, Dict, Any
from .base import BaseProcessor

class TextSplitter(BaseProcessor):
    def __init__(self, 
                 chunk_size: int = 1000,
                 chunk_overlap: int = 200,
                 separators: List[str] = None):
        """
        初始化文本分割器
        参数:
            chunk_size: 每个文本块的最大字符数
            chunk_overlap: 相邻文本块的重叠字符数
            separators: 分割文本时使用的分隔符列表，按优先级排序
        """
        super().__init__()
        self.chunk_size = chunk_size
        self.chunk_overlap = chunk_overlap
        self.separators = separators or ["\n\n", "\n", ". ", ", ", " ", "。"]

    def process(self, text: str) -> List[Dict[str, Any]]:
        """
        实现基类的process方法，将文本分割成块
        参数:
            text: 输入文本
        返回:
            包含文本块信息的字典列表
        """
        return self.split(text)

    def split(self, text: str) -> List[Dict[str, Any]]:
        """
        将文本分割成多个小块
        参数:
            text: 要分割的文本
        返回:
            包含文本块信息的字典列表
        """
        if not text:
            return []

        chunks = []
        start = 0
        chunk_index = 0
        text_length = len(text)

        while start < text_length:
            # 计算当前块的结束位置
            end = min(start + self.chunk_size, text_length)
            
            # 如果已经到达文本末尾，直接处理剩余文本
            if end >= text_length:
                split_point = text_length
            else:
                split_point = self._find_split_point(text, start, end)
            
            # 提取当前文本块
            chunk_text = text[start:split_point].strip()
            
            # 只添加非空的文本块
            if chunk_text:
                chunk = {
                    "content": chunk_text,
                    "index": chunk_index,
                    "metadata": {
                        "start_char": start,
                        "end_char": split_point,
                        "chunk_size": len(chunk_text)
                    }
                }
                chunks.append(chunk)
                chunk_index += 1
            
            # 更新下一个块的起始位置
            if split_point == start:  # 防止无限循环
                split_point = min(start + self.chunk_size, text_length)
            
            start = split_point
            if start < text_length:  # 考虑重叠
                start = max(start - self.chunk_overlap, 0)
            
            # 防止死循环
            if start >= text_length:
                break

        return chunks

    def _find_split_point(self, text: str, start: int, end: int) -> int:
        """
        在指定范围内寻找最佳分割点
        参数:
            text: 完整文本
            start: 起始位置
            end: 结束位置
        返回:
            最佳分割点的位置
        """
        if end >= len(text):
            return len(text)

        # 遍历所有分隔符，按优先级查找
        for separator in self.separators:
            # 在指定范围内查找最后一个分隔符
            position = text[start:end].rfind(separator)
            if position != -1:
                return start + position + len(separator)

        # 如果找不到任何分隔符，就在最大长度处直接分割
        return end
